import axios from 'axios'
import { message } from 'antd'
import { refreshTokenService } from '@/api/token'
import { storeStorageToken, removeStorageToken } from '@/utils/token'

const instance = axios.create({
  // ToDO：1. 基地址、超时时间
  baseURL: 'http://localhost:3333',  // 你的API服务器地址
  timeout: 10000,  // 请求超时时间
  // 必须加上这个选项才能跨域携带
  withCredentials: true
})

// 添加请求拦截器
instance.interceptors.request.use(
  (config) => {
    // 后端将token存在了cookie中，这里不需要携带token
    
    // 如果是FormData，不设置Content-Type，让浏览器自动设置
    // 如果是普通数据，设置为application/json
    if (!(config.data instanceof FormData)) {
      config.headers['Content-Type'] = 'application/json'
    }
    
    return config
  },
  (err) => Promise.reject(err)
)

// 标记是否正在刷新 Token（防止并发刷新）
let isRefreshing = false
// 保存所有因 Token 失效而等待新 Token 的请求回调函数
let refreshSubscribers = []

// 执行被挂起的请求
function onRefreshed(newToken) {
  storeStorageToken(newToken)
  refreshSubscribers.forEach((cb) => cb(newToken))
  refreshSubscribers = []
}

// 将等待刷新 Token 的请求封装成一个回调函数，加入队列中
function addRefreshSubscriber(callback) {
  refreshSubscribers.push(callback)
}

// 响应拦截器
instance.interceptors.response.use(
  (res) => {
    // 成功响应处理
    if (res.data.code === 200) {
      return res
    }
    // 业务失败处理
    const errorMessage = res.data.message || '服务异常'
    message.error(errorMessage)
    return Promise.reject(res.data)
  },
  async (err) => {
    const originalRequest = err.config
    
    // 网络错误处理
    if (!err.response) {
      message.error('网络连接失败，请检查网络设置')
      return Promise.reject(err)
    }
    
    const { status, data } = err.response
    
    // 401 未授权 - 尝试刷新token
    if (status === 401 && !originalRequest._retry) {
      console.log('进入拦截器401分支，刷新token逻辑')
      originalRequest._retry = true
      // 控制 Token 刷新流程（防止多次刷新）
      if (!isRefreshing) {
        // 标记刷新状态
        isRefreshing = true
        try {
          // 尝试刷新token
          const res = await refreshTokenService()
          if (res.data.code === 200) {
            // 刷新成功，存储新token
            storeStorageToken(res.data.data.token)
            // 执行队列中的请求
            onRefreshed(res.data.data.token)
            // 重试当前请求
            return instance(originalRequest)
          } else {
            // 刷新失败，清除本地token，跳转登录页
            removeStorageToken()
            message.error('登录已过期，请重新登录')
            window.location.href = '/login'
            return Promise.reject(err)
          }
        } catch (refreshError) {
          // 刷新token失败，清除本地token，跳转登录页
          removeStorageToken()
          message.error('登录已过期，请重新登录')
          window.location.href = '/login'
          return Promise.reject(refreshError)
        } finally {
          isRefreshing = false
        }
      }
      
      // 把当前请求放入队列，等待 Token 刷新后再重发
      return new Promise((resolve) => {
        addRefreshSubscriber((newToken) => {
          originalRequest.headers['Authorization'] = `Bearer ${newToken}`
          resolve(instance(originalRequest))
        })
      })
    }
    
    // 403 禁止访问 - token已过期
    if (status === 403) {
      removeStorageToken()
      message.error(data?.message || '登录已过期，请重新登录')
      window.location.href = '/login'
      return Promise.reject(err)
    }
    
    // 400 客户端错误
    if (status === 400) {
      const errorMessage = data?.message || '请求参数错误'
      message.error(errorMessage)
      return Promise.reject(err)
    }
    
    // 404 资源不存在
    if (status === 404) {
      message.error('请求的资源不存在')
      return Promise.reject(err)
    }
    
    // 500 服务器内部错误
    if (status >= 500) {
      const errorMessage = data?.message || '服务器内部错误，请稍后重试'
      message.error(errorMessage)
      return Promise.reject(err)
    }
    
    // 其他错误情况
    const errorMessage = data?.message || `请求失败 (${status})`
    message.error(errorMessage)
    return Promise.reject(err)
  }
)


export default instance
